home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_pyexpat.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  11.2 KB  |  413 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import pyexpat
  5. from xml.parsers import expat
  6. from test.test_support import sortdict, TestFailed
  7.  
  8. class Outputter:
  9.     
  10.     def StartElementHandler(self, name, attrs):
  11.         print 'Start element:\n\t', repr(name), sortdict(attrs)
  12.  
  13.     
  14.     def EndElementHandler(self, name):
  15.         print 'End element:\n\t', repr(name)
  16.  
  17.     
  18.     def CharacterDataHandler(self, data):
  19.         data = data.strip()
  20.         if data:
  21.             print 'Character data:'
  22.             print '\t', repr(data)
  23.         
  24.  
  25.     
  26.     def ProcessingInstructionHandler(self, target, data):
  27.         print 'PI:\n\t', repr(target), repr(data)
  28.  
  29.     
  30.     def StartNamespaceDeclHandler(self, prefix, uri):
  31.         print 'NS decl:\n\t', repr(prefix), repr(uri)
  32.  
  33.     
  34.     def EndNamespaceDeclHandler(self, prefix):
  35.         print 'End of NS decl:\n\t', repr(prefix)
  36.  
  37.     
  38.     def StartCdataSectionHandler(self):
  39.         print 'Start of CDATA section'
  40.  
  41.     
  42.     def EndCdataSectionHandler(self):
  43.         print 'End of CDATA section'
  44.  
  45.     
  46.     def CommentHandler(self, text):
  47.         print 'Comment:\n\t', repr(text)
  48.  
  49.     
  50.     def NotationDeclHandler(self, *args):
  51.         (name, base, sysid, pubid) = args
  52.         print 'Notation declared:', args
  53.  
  54.     
  55.     def UnparsedEntityDeclHandler(self, *args):
  56.         (entityName, base, systemId, publicId, notationName) = args
  57.         print 'Unparsed entity decl:\n\t', args
  58.  
  59.     
  60.     def NotStandaloneHandler(self, userData):
  61.         print 'Not standalone'
  62.         return 1
  63.  
  64.     
  65.     def ExternalEntityRefHandler(self, *args):
  66.         (context, base, sysId, pubId) = args
  67.         print 'External entity ref:', args[1:]
  68.         return 1
  69.  
  70.     
  71.     def DefaultHandler(self, userData):
  72.         pass
  73.  
  74.     
  75.     def DefaultHandlerExpand(self, userData):
  76.         pass
  77.  
  78.  
  79.  
  80. def confirm(ok):
  81.     if ok:
  82.         print 'OK.'
  83.     else:
  84.         print 'Not OK.'
  85.  
  86. out = Outputter()
  87. parser = expat.ParserCreate(namespace_separator = '!')
  88. parser.returns_unicode = 0
  89. confirm(parser.returns_unicode == 0)
  90. parser.returns_unicode = 1
  91. confirm(parser.returns_unicode == 1)
  92. parser.returns_unicode = 2
  93. confirm(parser.returns_unicode == 1)
  94. parser.returns_unicode = 0
  95. confirm(parser.returns_unicode == 0)
  96. parser.ordered_attributes = 0
  97. confirm(parser.ordered_attributes == 0)
  98. parser.ordered_attributes = 1
  99. confirm(parser.ordered_attributes == 1)
  100. parser.ordered_attributes = 2
  101. confirm(parser.ordered_attributes == 1)
  102. parser.ordered_attributes = 0
  103. confirm(parser.ordered_attributes == 0)
  104. parser.specified_attributes = 0
  105. confirm(parser.specified_attributes == 0)
  106. parser.specified_attributes = 1
  107. confirm(parser.specified_attributes == 1)
  108. parser.specified_attributes = 2
  109. confirm(parser.specified_attributes == 1)
  110. parser.specified_attributes = 0
  111. confirm(parser.specified_attributes == 0)
  112. HANDLER_NAMES = [
  113.     'StartElementHandler',
  114.     'EndElementHandler',
  115.     'CharacterDataHandler',
  116.     'ProcessingInstructionHandler',
  117.     'UnparsedEntityDeclHandler',
  118.     'NotationDeclHandler',
  119.     'StartNamespaceDeclHandler',
  120.     'EndNamespaceDeclHandler',
  121.     'CommentHandler',
  122.     'StartCdataSectionHandler',
  123.     'EndCdataSectionHandler',
  124.     'DefaultHandler',
  125.     'DefaultHandlerExpand',
  126.     'ExternalEntityRefHandler']
  127. for name in HANDLER_NAMES:
  128.     setattr(parser, name, getattr(out, name))
  129.  
  130. data = '<?xml version="1.0" encoding="iso-8859-1" standalone="no"?>\n<?xml-stylesheet href="stylesheet.css"?>\n<!-- comment data -->\n<!DOCTYPE quotations SYSTEM "quotations.dtd" [\n<!ELEMENT root ANY>\n<!NOTATION notation SYSTEM "notation.jpeg">\n<!ENTITY acirc "â">\n<!ENTITY external_entity SYSTEM "entity.file">\n<!ENTITY unparsed_entity SYSTEM "entity.file" NDATA notation>\n%unparsed_entity;\n]>\n\n<root attr1="value1" attr2="value2ὀ">\n<myns:subelement xmlns:myns="http://www.python.org/namespace">\n     Contents of subelements\n</myns:subelement>\n<sub2><![CDATA[contents of CDATA section]]></sub2>\n&external_entity;\n</root>\n'
  131. parser.returns_unicode = 0
  132.  
  133. try:
  134.     parser.Parse(data, 1)
  135. except expat.error:
  136.     print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
  137.     print '** Line', parser.ErrorLineNumber
  138.     print '** Column', parser.ErrorColumnNumber
  139.     print '** Byte', parser.ErrorByteIndex
  140.  
  141. parser = expat.ParserCreate(namespace_separator = '!')
  142. parser.returns_unicode = 1
  143. for name in HANDLER_NAMES:
  144.     setattr(parser, name, getattr(out, name))
  145.  
  146.  
  147. try:
  148.     parser.Parse(data, 1)
  149. except expat.error:
  150.     print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
  151.     print '** Line', parser.ErrorLineNumber
  152.     print '** Column', parser.ErrorColumnNumber
  153.     print '** Byte', parser.ErrorByteIndex
  154.  
  155. parser = expat.ParserCreate(namespace_separator = '!')
  156. parser.returns_unicode = 1
  157. for name in HANDLER_NAMES:
  158.     setattr(parser, name, getattr(out, name))
  159.  
  160. import StringIO
  161. file = StringIO.StringIO(data)
  162.  
  163. try:
  164.     parser.ParseFile(file)
  165. except expat.error:
  166.     print '** Error', parser.ErrorCode, expat.ErrorString(parser.ErrorCode)
  167.     print '** Line', parser.ErrorLineNumber
  168.     print '** Column', parser.ErrorColumnNumber
  169.     print '** Byte', parser.ErrorByteIndex
  170.  
  171. print 
  172. print 'Testing constructor for proper handling of namespace_separator values:'
  173. expat.ParserCreate()
  174. expat.ParserCreate(namespace_separator = None)
  175. expat.ParserCreate(namespace_separator = ' ')
  176. print 'Legal values tested o.k.'
  177.  
  178. try:
  179.     expat.ParserCreate(namespace_separator = 42)
  180. except TypeError:
  181.     e = None
  182.     print 'Caught expected TypeError:'
  183.     print e
  184.  
  185. print 'Failed to catch expected TypeError.'
  186.  
  187. try:
  188.     expat.ParserCreate(namespace_separator = 'too long')
  189. except ValueError:
  190.     e = None
  191.     print 'Caught expected ValueError:'
  192.     print e
  193.  
  194. print 'Failed to catch expected ValueError.'
  195. expat.ParserCreate(namespace_separator = '')
  196. p = expat.ParserCreate()
  197. L = []
  198.  
  199. def collector(name, *args):
  200.     L.append(name)
  201.  
  202. p.StartElementHandler = collector
  203. p.EndElementHandler = collector
  204. p.Parse('<e> <e/> <e></e> </e>', 1)
  205. tag = L[0]
  206. if len(L) != 6:
  207.     print 'L should only contain 6 entries; found', len(L)
  208.  
  209. for entry in L:
  210.     if tag is not entry:
  211.         print 'expected L to contain many references to the same string', "(it didn't)"
  212.         print 'L =', repr(L)
  213.         break
  214.         continue
  215.  
  216. import sys
  217.  
  218. class TextCollector:
  219.     
  220.     def __init__(self, parser):
  221.         self.stuff = []
  222.  
  223.     
  224.     def check(self, expected, label):
  225.         require(self.stuff == expected, '%s\nstuff    = %r\nexpected = %r' % (label, self.stuff, map(unicode, expected)))
  226.  
  227.     
  228.     def CharacterDataHandler(self, text):
  229.         self.stuff.append(text)
  230.  
  231.     
  232.     def StartElementHandler(self, name, attrs):
  233.         self.stuff.append('<%s>' % name)
  234.         bt = attrs.get('buffer-text')
  235.         if bt == 'yes':
  236.             parser.buffer_text = 1
  237.         elif bt == 'no':
  238.             parser.buffer_text = 0
  239.         
  240.  
  241.     
  242.     def EndElementHandler(self, name):
  243.         self.stuff.append('</%s>' % name)
  244.  
  245.     
  246.     def CommentHandler(self, data):
  247.         self.stuff.append('<!--%s-->' % data)
  248.  
  249.  
  250.  
  251. def require(cond, label):
  252.     if not cond:
  253.         raise TestFailed(label)
  254.     
  255.  
  256.  
  257. def setup(handlers = []):
  258.     parser = expat.ParserCreate()
  259.     require(not (parser.buffer_text), 'buffer_text not disabled by default')
  260.     parser.buffer_text = 1
  261.     handler = TextCollector(parser)
  262.     parser.CharacterDataHandler = handler.CharacterDataHandler
  263.     for name in handlers:
  264.         setattr(parser, name, getattr(handler, name))
  265.     
  266.     return (parser, handler)
  267.  
  268. (parser, handler) = setup()
  269. require(parser.buffer_text, 'text buffering either not acknowledged or not enabled')
  270. parser.Parse('<a>1<b/>2<c/>3</a>', 1)
  271. handler.check([
  272.     '123'], 'buffered text not properly collapsed')
  273. (parser, handler) = setup([
  274.     'StartElementHandler'])
  275. parser.Parse("<a>1<b buffer-text='no'/>2\n3<c buffer-text='yes'/>4\n5</a>", 1)
  276. handler.check([
  277.     '<a>',
  278.     '1',
  279.     '<b>',
  280.     '2',
  281.     '\n',
  282.     '3',
  283.     '<c>',
  284.     '4\n5'], 'buffering control not reacting as expected')
  285. (parser, handler) = setup()
  286. parser.Parse('<a>1<b/><2><c/> \n 3</a>', 1)
  287. handler.check([
  288.     '1<2> \n 3'], 'buffered text not properly collapsed')
  289. (parser, handler) = setup([
  290.     'StartElementHandler'])
  291. parser.Parse('<a>1<b/>2<c/>3</a>', 1)
  292. handler.check([
  293.     '<a>',
  294.     '1',
  295.     '<b>',
  296.     '2',
  297.     '<c>',
  298.     '3'], 'buffered text not properly split')
  299. (parser, handler) = setup([
  300.     'StartElementHandler',
  301.     'EndElementHandler'])
  302. parser.CharacterDataHandler = None
  303. parser.Parse('<a>1<b/>2<c/>3</a>', 1)
  304. handler.check([
  305.     '<a>',
  306.     '<b>',
  307.     '</b>',
  308.     '<c>',
  309.     '</c>',
  310.     '</a>'], 'huh?')
  311. (parser, handler) = setup([
  312.     'StartElementHandler',
  313.     'EndElementHandler'])
  314. parser.Parse('<a>1<b></b>2<c/>3</a>', 1)
  315. handler.check([
  316.     '<a>',
  317.     '1',
  318.     '<b>',
  319.     '</b>',
  320.     '2',
  321.     '<c>',
  322.     '</c>',
  323.     '3',
  324.     '</a>'], 'huh?')
  325. (parser, handler) = setup([
  326.     'CommentHandler',
  327.     'EndElementHandler',
  328.     'StartElementHandler'])
  329. parser.Parse('<a>1<b/>2<c></c>345</a> ', 1)
  330. handler.check([
  331.     '<a>',
  332.     '1',
  333.     '<b>',
  334.     '</b>',
  335.     '2',
  336.     '<c>',
  337.     '</c>',
  338.     '345',
  339.     '</a>'], 'buffered text not properly split')
  340. (parser, handler) = setup([
  341.     'CommentHandler',
  342.     'EndElementHandler',
  343.     'StartElementHandler'])
  344. parser.Parse('<a>1<b/>2<c></c>3<!--abc-->4<!--def-->5</a> ', 1)
  345. handler.check([
  346.     '<a>',
  347.     '1',
  348.     '<b>',
  349.     '</b>',
  350.     '2',
  351.     '<c>',
  352.     '</c>',
  353.     '3',
  354.     '<!--abc-->',
  355.     '4',
  356.     '<!--def-->',
  357.     '5',
  358.     '</a>'], 'buffered text not properly split')
  359.  
  360. def StartElementHandler(name, attrs):
  361.     raise RuntimeError(name)
  362.  
  363. parser = expat.ParserCreate()
  364. parser.StartElementHandler = StartElementHandler
  365.  
  366. try:
  367.     parser.Parse('<a><b><c/></b></a>', 1)
  368. except RuntimeError:
  369.     e = None
  370.     if e.args[0] != 'a':
  371.         print "Expected RuntimeError for element 'a'; found %r" % e.args[0]
  372.     
  373. except:
  374.     e.args[0] != 'a'
  375.  
  376. print "Expected RuntimeError for 'a'"
  377.  
  378. class PositionTest:
  379.     
  380.     def __init__(self, expected_list, parser):
  381.         self.parser = parser
  382.         self.parser.StartElementHandler = self.StartElementHandler
  383.         self.parser.EndElementHandler = self.EndElementHandler
  384.         self.expected_list = expected_list
  385.         self.upto = 0
  386.  
  387.     
  388.     def StartElementHandler(self, name, attrs):
  389.         self.check_pos('s')
  390.  
  391.     
  392.     def EndElementHandler(self, name):
  393.         self.check_pos('e')
  394.  
  395.     
  396.     def check_pos(self, event):
  397.         pos = (event, self.parser.CurrentByteIndex, self.parser.CurrentLineNumber, self.parser.CurrentColumnNumber)
  398.         require(self.upto < len(self.expected_list), 'too many parser events')
  399.         expected = self.expected_list[self.upto]
  400.         require(pos == expected, 'expected position %s, got %s' % (expected, pos))
  401.         self.upto += 1
  402.  
  403.  
  404. parser = expat.ParserCreate()
  405. handler = PositionTest([
  406.     ('s', 0, 1, 0),
  407.     ('s', 5, 2, 1),
  408.     ('s', 11, 3, 2),
  409.     ('e', 15, 3, 6),
  410.     ('e', 17, 4, 1),
  411.     ('e', 22, 5, 0)], parser)
  412. parser.Parse('<a>\n <b>\n  <c/>\n </b>\n</a>', 1)
  413.